juce/source/extras/the jucer/src/model/jucer_ComponentLayout.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../jucer_Headers.h"
  27 #include "jucer_JucerDocument.h"
  28 #include "jucer_ObjectTypes.h"
  29 #include "../ui/jucer_JucerDocumentHolder.h"
  30 #include "components/jucer_ComponentUndoableAction.h"
  31
  32
  33 //==============================================================================
  34 ComponentLayout::ComponentLayout()
  35     : document (0),
  36       nextCompUID (1)
  37 {
  38 }
  39
  40 ComponentLayout::~ComponentLayout()
  41 {
  42     components.clear();
  43 }
  44
  45 //==============================================================================
  46 void ComponentLayout::changed()
  47 {
  48     if (document != 0)
  49         document->changed();
  50 }
  51
  52 void ComponentLayout::perform (UndoableAction* action, const String& actionName)
  53 {
  54     jassert (document != 0);
  55
  56     if (document != 0)
  57     {
  58         document->getUndoManager().perform (action, actionName);
  59     }
  60     else
  61     {
  62         action->perform();
  63         delete action;
  64     }
  65 }
  66
  67 //==============================================================================
  68 void ComponentLayout::clearComponents()
  69 {
  70     selected.deselectAll();
  71     components.clear();
  72     changed();
  73 }
  74
  75 //==============================================================================
  76 class AddCompAction  : public UndoableAction
  77 {
  78 public:
  79     AddCompAction (XmlElement* const xml_, ComponentLayout& layout_)
  80        : indexAdded (-1),
  81          xml (xml_),
  82          layout (layout_)
  83     {
  84     }
  85
  86     ~AddCompAction()
  87     {
  88         delete xml;
  89     }
  90
  91     bool perform()
  92     {
  93         showCorrectTab();
  94         Component* const newComp = layout.addComponentFromXml (*xml, false);
  95         jassert (newComp != 0);
  96
  97         indexAdded = layout.indexOfComponent (newComp);
  98         jassert (indexAdded >= 0);
  99         return indexAdded >= 0;
 100     }
 101
 102     bool undo()
 103     {
 104         showCorrectTab();
 105         layout.removeComponent (layout.getComponent (indexAdded), false);
 106         return true;
 107     }
 108
 109     int getSizeInUnits()    { return 10; }
 110
 111     int indexAdded;
 112
 113 private:
 114     XmlElement* xml;
 115     ComponentLayout& layout;
 116
 117     static void showCorrectTab()
 118     {
 119         JucerDocumentHolder* const docHolder = JucerDocumentHolder::getActiveDocumentHolder();
 120
 121         if (docHolder != 0)
 122             docHolder->showLayout();
 123     }
 124
 125     AddCompAction (const AddCompAction&);
 126     AddCompAction& operator= (const AddCompAction&);
 127 };
 128
 129 //==============================================================================
 130 class DeleteCompAction  : public ComponentUndoableAction <Component>
 131 {
 132 public:
 133     DeleteCompAction (Component* const comp, ComponentLayout& layout)
 134        : ComponentUndoableAction <Component> (comp, layout),
 135          oldIndex (-1)
 136     {
 137         ComponentTypeHandler* const h = ComponentTypeHandler::getHandlerFor (*comp);
 138         jassert (h != 0);
 139         if (h != 0)
 140             xml = h->createXmlFor (comp, &layout);
 141         else
 142             xml = 0;
 143
 144         oldIndex = layout.indexOfComponent (comp);
 145     }
 146
 147     ~DeleteCompAction()
 148     {
 149         delete xml;
 150     }
 151
 152     bool perform()
 153     {
 154         showCorrectTab();
 155         layout.removeComponent (getComponent(), false);
 156         return true;
 157     }
 158
 159     bool undo()
 160     {
 161         Component* c = layout.addComponentFromXml (*xml, false);
 162         jassert (c != 0);
 163
 164         layout.moveComponentZOrder (layout.indexOfComponent (c), oldIndex);
 165
 166         showCorrectTab();
 167         return c != 0;
 168     }
 169
 170 private:
 171     XmlElement* xml;
 172     int oldIndex;
 173 };
 174
 175 void ComponentLayout::removeComponent (Component* comp, const bool undoable)
 176 {
 177     if (comp != 0 && components.contains (comp))
 178     {
 179         if (undoable)
 180         {
 181             perform (new DeleteCompAction (comp, *this), "Delete components");
 182         }
 183         else
 184         {
 185             selected.deselect (comp);
 186             selected.changed (true); // synchronous message to get rid of any property components
 187
 188             components.removeObject (comp);
 189             changed();
 190         }
 191     }
 192 }
 193
 194 //==============================================================================
 195 class FrontBackCompAction  : public ComponentUndoableAction <Component>
 196 {
 197 public:
 198     FrontBackCompAction (Component* const comp, ComponentLayout& layout, int newIndex_)
 199        : ComponentUndoableAction <Component> (comp, layout),
 200          newIndex (newIndex_)
 201     {
 202         oldIndex = layout.indexOfComponent (comp);
 203     }
 204
 205     bool perform()
 206     {
 207         showCorrectTab();
 208         Component* comp = layout.getComponent (oldIndex);
 209         layout.moveComponentZOrder (oldIndex, newIndex);
 210         newIndex = layout.indexOfComponent (comp);
 211         return true;
 212     }
 213
 214     bool undo()
 215     {
 216         showCorrectTab();
 217         layout.moveComponentZOrder (newIndex, oldIndex);
 218         return true;
 219     }
 220
 221 private:
 222     int newIndex, oldIndex;
 223 };
 224
 225 void ComponentLayout::moveComponentZOrder (int oldIndex, int newIndex)
 226 {
 227     jassert (components [oldIndex] != 0);
 228
 229     if (oldIndex != newIndex && components [oldIndex] != 0)
 230     {
 231         components.move (oldIndex, newIndex);
 232         changed();
 233     }
 234 }
 235
 236 void ComponentLayout::componentToFront (Component* comp, const bool undoable)
 237 {
 238     if (comp != 0 && components.contains (comp))
 239     {
 240         if (undoable)
 241             perform (new FrontBackCompAction (comp, *this, -1), "Move components to front");
 242         else
 243             moveComponentZOrder (components.indexOf (comp), -1);
 244     }
 245 }
 246
 247 void ComponentLayout::componentToBack (Component* comp, const bool undoable)
 248 {
 249     if (comp != 0 && components.contains (comp))
 250     {
 251         if (undoable)
 252             perform (new FrontBackCompAction (comp, *this, 0), "Move components to back");
 253         else
 254             moveComponentZOrder (components.indexOf (comp), 0);
 255     }
 256 }
 257
 258
 259 //==============================================================================
 260 const char* const ComponentLayout::clipboardXmlTag = "COMPONENTS";
 261
 262 void ComponentLayout::copySelectedToClipboard()
 263 {
 264     if (selected.getNumSelected() == 0)
 265         return;
 266
 267     XmlElement clip (clipboardXmlTag);
 268
 269     for (int i = 0; i < components.size(); ++i)
 270     {
 271         Component* const c = components.getUnchecked(i);
 272
 273         if (selected.isSelected (c))
 274         {
 275             ComponentTypeHandler* const type = ComponentTypeHandler::getHandlerFor (*c);
 276
 277             jassert (type != 0);
 278             if (type != 0)
 279             {
 280                 XmlElement* const e = type->createXmlFor (c, this);
 281                 clip.addChildElement (e);
 282             }
 283         }
 284     }
 285
 286     SystemClipboard::copyTextToClipboard (clip.createDocument (String::empty, false, false));
 287 }
 288
 289 void ComponentLayout::paste()
 290 {
 291     XmlDocument clip (SystemClipboard::getTextFromClipboard());
 292     XmlElement* const doc = clip.getDocumentElement();
 293
 294     if (doc != 0 && doc->hasTagName (clipboardXmlTag))
 295     {
 296         selected.deselectAll();
 297
 298         forEachXmlChildElement (*doc, e)
 299         {
 300             Component* newComp = addComponentFromXml (*e, true);
 301
 302             if (newComp != 0)
 303                 selected.addToSelection (newComp);
 304         }
 305
 306         startDragging();
 307         dragSelectedComps (Random::getSystemRandom().nextInt (40),
 308                            Random::getSystemRandom().nextInt (40));
 309         endDragging();
 310     }
 311
 312     delete doc;
 313 }
 314
 315 void ComponentLayout::deleteSelected()
 316 {
 317     const SelectedItemSet <Component*> temp (selected);
 318     selected.deselectAll();
 319     selected.changed (true); // synchronous message to get rid of any property components
 320
 321     if (temp.getNumSelected() > 0)
 322     {
 323         for (int i = temp.getNumSelected(); --i >= 0;)
 324             removeComponent (temp.getSelectedItem (i), true);
 325
 326         changed();
 327
 328         if (document != 0)
 329             document->dispatchPendingMessages(); // forces the change to propagate before a paint() callback can happen,
 330                                                  // in case there are components floating around that are now dangling pointers
 331     }
 332 }
 333
 334 void ComponentLayout::selectAll()
 335 {
 336     for (int i = 0; i < components.size(); ++i)
 337         selected.addToSelection (components.getUnchecked (i));
 338 }
 339
 340 void ComponentLayout::selectedToFront()
 341 {
 342     const SelectedItemSet <Component*> temp (selected);
 343
 344     for (int i = temp.getNumSelected(); --i >= 0;)
 345         componentToFront (temp.getSelectedItem(i), true);
 346 }
 347
 348 void ComponentLayout::selectedToBack()
 349 {
 350     const SelectedItemSet <Component*> temp (selected);
 351
 352     for (int i = 0; i < temp.getNumSelected(); ++i)
 353         componentToBack (temp.getSelectedItem(i), true);
 354 }
 355
 356 void ComponentLayout::bringLostItemsBackOnScreen (int width, int height)
 357 {
 358     for (int i = components.size(); --i >= 0;)
 359     {
 360         Component* const c = components[i];
 361
 362         if (! c->getBounds().intersects (Rectangle<int> (0, 0, width, height)))
 363         {
 364             c->setTopLeftPosition (width / 2, height / 2);
 365             updateStoredComponentPosition (c, false);
 366         }
 367     }
 368 }
 369
 370 Component* ComponentLayout::addNewComponent (ComponentTypeHandler* const type, int x, int y)
 371 {
 372     Component* c = type->createNewComponent (getDocument());
 373     jassert (c != 0);
 374
 375     if (c != 0)
 376     {
 377         c->setSize (type->getDefaultWidth(), type->getDefaultHeight());
 378         c->setCentrePosition (x, y);
 379         updateStoredComponentPosition (c, false);
 380
 381         c->getProperties().set ("id", nextCompUID++);
 382
 383         XmlElement* xml = type->createXmlFor (c, this);
 384         delete c;
 385
 386         c = addComponentFromXml (*xml, true);
 387         delete xml;
 388
 389         String memberName (makeValidCppIdentifier (type->getClassName (c), true, true, false));
 390         setComponentMemberVariableName (c, memberName);
 391
 392         selected.selectOnly (c);
 393     }
 394
 395     return c;
 396 }
 397
 398
 399 Component* ComponentLayout::addComponentFromXml (const XmlElement& xml, const bool undoable)
 400 {
 401     if (undoable)
 402     {
 403         AddCompAction* const action = new AddCompAction (new XmlElement (xml), *this);
 404         perform (action, "Add new components");
 405
 406         return components [action->indexAdded];
 407     }
 408     else
 409     {
 410         ComponentTypeHandler* const type
 411             = ComponentTypeHandler::getHandlerForXmlTag (xml.getTagName());
 412
 413         if (type != 0)
 414         {
 415             Component* const newComp = type->createNewComponent (getDocument());
 416
 417             if (type->restoreFromXml (xml, newComp, this))
 418             {
 419                 // ensure that the new comp's name is unique
 420                 setComponentMemberVariableName (newComp, getComponentMemberVariableName (newComp));
 421
 422                 // check for duped IDs..
 423                 while (findComponentWithId (ComponentTypeHandler::getComponentId (newComp)) != 0)
 424                     ComponentTypeHandler::setComponentId (newComp, Random::getSystemRandom().nextInt64());
 425
 426                 components.add (newComp);
 427                 changed();
 428                 return newComp;
 429             }
 430             else
 431             {
 432                 delete newComp;
 433             }
 434         }
 435
 436         return 0;
 437     }
 438 }
 439
 440 Component* ComponentLayout::findComponentWithId (const int64 componentId) const
 441 {
 442     for (int i = 0; i < components.size(); ++i)
 443         if (ComponentTypeHandler::getComponentId (components.getUnchecked(i)) == componentId)
 444             return components.getUnchecked(i);
 445
 446     return 0;
 447 }
 448
 449 //==============================================================================
 450 static const char* const dimensionSuffixes[] = { "X", "Y", "W", "H" };
 451
 452 Component* ComponentLayout::getComponentRelativePosTarget (Component* comp, int whichDimension) const
 453 {
 454     jassert (comp != 0);
 455
 456     PaintElement* const pe = dynamic_cast <PaintElement*> (comp);
 457
 458     if (pe != 0)
 459     {
 460         int64 compId;
 461
 462         if (whichDimension == 0)
 463             compId = pe->getPosition().relativeToX;
 464         else if (whichDimension == 1)
 465             compId = pe->getPosition().relativeToY;
 466         else if (whichDimension == 2)
 467             compId = pe->getPosition().relativeToW;
 468         else
 469             compId = pe->getPosition().relativeToH;
 470
 471         return findComponentWithId (compId);
 472     }
 473     else
 474     {
 475         return findComponentWithId (comp->getProperties() [String ("relativeTo") + dimensionSuffixes [whichDimension]]
 476                                         .toString().getHexValue64());
 477     }
 478 }
 479
 480 void ComponentLayout::setComponentRelativeTarget (Component* comp, int whichDimension, Component* compToBeRelativeTo)
 481 {
 482     PaintElement* const pe = dynamic_cast <PaintElement*> (comp);
 483
 484     jassert (comp != 0);
 485     jassert (pe != 0 || components.contains (comp));
 486     jassert (compToBeRelativeTo == 0 || components.contains (compToBeRelativeTo));
 487     jassert (compToBeRelativeTo == 0 || ! dependsOnComponentForRelativePos (compToBeRelativeTo, comp));
 488
 489     if (compToBeRelativeTo != getComponentRelativePosTarget (comp, whichDimension)
 490          && (compToBeRelativeTo == 0 || ! dependsOnComponentForRelativePos (compToBeRelativeTo, comp)))
 491     {
 492         const int64 compId = ComponentTypeHandler::getComponentId (compToBeRelativeTo);
 493
 494         Rectangle<int> oldBounds (comp->getBounds());
 495         RelativePositionedRectangle pos;
 496
 497         if (pe != 0)
 498         {
 499             oldBounds = pe->getCurrentBounds (dynamic_cast <PaintRoutineEditor*> (pe->getParentComponent())->getComponentArea());
 500             pos = pe->getPosition();
 501         }
 502         else
 503         {
 504             pos = ComponentTypeHandler::getComponentPosition (comp);
 505         }
 506
 507         if (whichDimension == 0)
 508             pos.relativeToX = compId;
 509         else if (whichDimension == 1)
 510             pos.relativeToY = compId;
 511         else if (whichDimension == 2)
 512             pos.relativeToW = compId;
 513         else if (whichDimension == 3)
 514             pos.relativeToH = compId;
 515
 516         if (pe != 0)
 517         {
 518             pe->setPosition (pos, true);
 519             pe->setCurrentBounds (oldBounds, dynamic_cast <PaintRoutineEditor*> (pe->getParentComponent())->getComponentArea(), true);
 520         }
 521         else
 522         {
 523             setComponentPosition (comp, pos, true);
 524             comp->setBounds (oldBounds);
 525             updateStoredComponentPosition (comp, false);
 526         }
 527
 528         changed();
 529     }
 530 }
 531
 532 bool ComponentLayout::dependsOnComponentForRelativePos (Component* comp, Component* possibleDependee) const
 533 {
 534     for (int i = 0; i < 4; ++i)
 535     {
 536         Component* const c = getComponentRelativePosTarget (comp, i);
 537         if (c != 0 && (c == possibleDependee || dependsOnComponentForRelativePos (c, possibleDependee)))
 538             return true;
 539     }
 540
 541     return false;
 542 }
 543
 544 const int menuIdBase = 0x63240000;
 545
 546 PopupMenu ComponentLayout::getRelativeTargetMenu (Component* comp, int whichDimension) const
 547 {
 548     PopupMenu m;
 549
 550     Component* const current = getComponentRelativePosTarget (comp, whichDimension);
 551
 552     m.addItem (menuIdBase, "Relative to parent component", true, current == 0);
 553     m.addSeparator();
 554
 555     for (int i = 0; i < components.size(); ++i)
 556     {
 557         Component* const c = components.getUnchecked(i);
 558
 559         if (c != comp)
 560         {
 561             m.addItem (menuIdBase + i + 1,
 562                        "Relative to " + getComponentMemberVariableName (c)
 563                         + " (class: " + ComponentTypeHandler::getHandlerFor (*c)->getClassName (c) + ")",
 564                        ! dependsOnComponentForRelativePos (c, comp),
 565                        current == c);
 566         }
 567     }
 568
 569     return m;
 570 }
 571
 572 void ComponentLayout::processRelativeTargetMenuResult (Component* comp, int whichDimension, int menuResultID)
 573 {
 574     if (menuResultID != 0)
 575     {
 576         Component* const newTarget = components [menuResultID - menuIdBase - 1];
 577         setComponentRelativeTarget (comp, whichDimension, newTarget);
 578     }
 579 }
 580
 581 //==============================================================================
 582 class ChangeCompPositionAction  : public ComponentUndoableAction <Component>
 583 {
 584 public:
 585     ChangeCompPositionAction (Component* const comp, ComponentLayout& layout,
 586                               const RelativePositionedRectangle& newPos_)
 587        : ComponentUndoableAction <Component> (comp, layout),
 588          newPos (newPos_)
 589     {
 590         oldPos = ComponentTypeHandler::getComponentPosition (comp);
 591     }
 592
 593     bool perform()
 594     {
 595         showCorrectTab();
 596         layout.setComponentPosition (getComponent(), newPos, false);
 597         return true;
 598     }
 599
 600     bool undo()
 601     {
 602         showCorrectTab();
 603         layout.setComponentPosition (getComponent(), oldPos, false);
 604         return true;
 605     }
 606
 607 private:
 608     RelativePositionedRectangle newPos, oldPos;
 609 };
 610
 611 void ComponentLayout::setComponentPosition (Component* comp,
 612                                             const RelativePositionedRectangle& newPos,
 613                                             const bool undoable)
 614 {
 615     if (ComponentTypeHandler::getComponentPosition (comp) != newPos)
 616     {
 617         if (undoable)
 618         {
 619             perform (new ChangeCompPositionAction (comp, *this, newPos), "Move components");
 620         }
 621         else
 622         {
 623             ComponentTypeHandler::setComponentPosition (comp, newPos, this);
 624             changed();
 625         }
 626     }
 627 }
 628
 629 void ComponentLayout::updateStoredComponentPosition (Component* comp, const bool undoable)
 630 {
 631     RelativePositionedRectangle newPos (ComponentTypeHandler::getComponentPosition (comp));
 632
 633     newPos.updateFromComponent (*comp, this);
 634
 635     setComponentPosition (comp, newPos, undoable);
 636 }
 637
 638 //==============================================================================
 639 void ComponentLayout::startDragging()
 640 {
 641     for (int i = 0; i < components.size(); ++i)
 642     {
 643         Component* const c = components[i];
 644         c->getProperties().set ("xDragStart", c->getX());
 645         c->getProperties().set ("yDragStart", c->getY());
 646     }
 647
 648     jassert (document != 0);
 649     document->getUndoManager().beginNewTransaction();
 650 }
 651
 652 void ComponentLayout::dragSelectedComps (int dx, int dy, const bool allowSnap)
 653 {
 654     if (allowSnap && document != 0 && selected.getNumSelected() > 1)
 655     {
 656         dx = document->snapPosition (dx);
 657         dy = document->snapPosition (dy);
 658     }
 659
 660     for (int i = 0; i < selected.getNumSelected(); ++i)
 661     {
 662         Component* const c = selected.getSelectedItem (i);
 663
 664         const int startX = c->getProperties() ["xDragStart"];
 665         const int startY = c->getProperties() ["yDragStart"];
 666
 667         if (allowSnap && document != 0 && selected.getNumSelected() == 1)
 668         {
 669             c->setTopLeftPosition (document->snapPosition (startX + dx),
 670                                    document->snapPosition (startY + dy));
 671         }
 672         else
 673         {
 674             c->setTopLeftPosition (startX + dx,
 675                                    startY + dy);
 676         }
 677
 678         updateStoredComponentPosition (c, false);
 679     }
 680 }
 681
 682 void ComponentLayout::endDragging()
 683 {
 684     // after the drag, roll back all the comps to their start position, then
 685     // back to their finish positions using an undoable command.
 686     document->getUndoManager().beginNewTransaction();
 687
 688     for (int i = 0; i < selected.getNumSelected(); ++i)
 689     {
 690         Component* const c = selected.getSelectedItem (i);
 691
 692         const int newX = c->getX();
 693         const int newY = c->getY();
 694
 695         const int startX = c->getProperties() ["xDragStart"];
 696         const int startY = c->getProperties() ["yDragStart"];
 697
 698         c->setTopLeftPosition (startX, startY);
 699         updateStoredComponentPosition (c, false);
 700
 701         c->setTopLeftPosition (newX, newY);
 702         updateStoredComponentPosition (c, true);
 703     }
 704
 705     document->getUndoManager().beginNewTransaction();
 706 }
 707
 708 void ComponentLayout::moveSelectedComps (int dx, int dy, bool snap)
 709 {
 710     startDragging();
 711     dragSelectedComps (dx, dy, snap);
 712     endDragging();
 713 }
 714
 715 void ComponentLayout::stretchSelectedComps (int dw, int dh, bool allowSnap)
 716 {
 717     int neww, newh;
 718
 719     if (document != 0 && selected.getNumSelected() == 1)
 720     {
 721         Component* const c = selected.getSelectedItem (0);
 722
 723         if (allowSnap)
 724         {
 725             int bot = c->getBottom() + dh;
 726             int right = c->getRight() + dw;
 727             bot = (dh != 0) ? document->snapPosition (bot) : bot;
 728             right = (dw != 0) ? document->snapPosition (right) : right;
 729             newh = bot - c->getY();
 730             neww = right - c->getX();
 731         }
 732         else
 733         {
 734             newh = c->getHeight() + dh;
 735             neww = c->getWidth() + dw;
 736         }
 737
 738         c->setSize (neww, newh);
 739
 740         updateStoredComponentPosition (c, true);
 741     }
 742     else
 743     {
 744         for (int i = 0; i < selected.getNumSelected(); ++i)
 745         {
 746             Component* const c = selected.getSelectedItem (i);
 747
 748             neww = c->getWidth() + dw;
 749             newh = c->getHeight() + dh;
 750             c->setSize (neww, newh);
 751
 752             updateStoredComponentPosition (c, true);
 753         }
 754     }
 755 }
 756
 757
 758 //==============================================================================
 759 void ComponentLayout::fillInGeneratedCode (GeneratedCode& code) const
 760 {
 761     for (int i = 0; i < components.size(); ++i)
 762     {
 763         Component* const comp = components[i];
 764         ComponentTypeHandler* const type = ComponentTypeHandler::getHandlerFor (*comp);
 765
 766         if (type != 0)
 767             type->fillInGeneratedCode (comp, code);
 768     }
 769 }
 770
 771 //==============================================================================
 772 const String ComponentLayout::getComponentMemberVariableName (Component* comp) const
 773 {
 774     if (comp == 0)
 775         return String::empty;
 776
 777     String name (comp->getProperties() ["memberName"].toString());
 778
 779     if (name.isEmpty())
 780         name = getUnusedMemberName (makeValidCppIdentifier (comp->getName(), true, true, false), comp);
 781
 782     return name;
 783 }
 784
 785 void ComponentLayout::setComponentMemberVariableName (Component* comp, const String& newName)
 786 {
 787     const String oldName (getComponentMemberVariableName (comp));
 788
 789     comp->getProperties().set ("memberName", String::empty);
 790
 791     const String n (getUnusedMemberName (makeValidCppIdentifier (newName, false, true, false), comp));
 792     comp->getProperties().set ("memberName", n);
 793
 794     if (n != oldName)
 795         changed();
 796 }
 797
 798 const String ComponentLayout::getUnusedMemberName (String nameRoot, Component* comp) const
 799 {
 800     String n (nameRoot);
 801
 802     while (CharacterFunctions::isDigit (nameRoot.getLastCharacter()))
 803         nameRoot = nameRoot.dropLastCharacters (1);
 804
 805     int suffix = 2;
 806
 807     for (;;)
 808     {
 809         bool alreadyUsed = false;
 810
 811         for (int i = 0; i < components.size(); ++i)
 812         {
 813             if (components[i] != comp
 814                  && components[i]->getProperties() ["memberName"] == n)
 815             {
 816                 alreadyUsed = true;
 817                 break;
 818             }
 819         }
 820
 821         if (! alreadyUsed)
 822             break;
 823
 824         n = nameRoot + String (suffix++);
 825     }
 826
 827     return n;
 828 }
 829
 830 //==============================================================================
 831 const String ComponentLayout::getComponentVirtualClassName (Component* comp) const
 832 {
 833     if (comp == 0)
 834         return String::empty;
 835
 836     return comp->getProperties() ["virtualName"];
 837 }
 838
 839 void ComponentLayout::setComponentVirtualClassName (Component* comp, const String& newName)
 840 {
 841     const String name (makeValidCppIdentifier (newName, false, false, true));
 842
 843     if (name != getComponentVirtualClassName (comp))
 844     {
 845         comp->getProperties().set ("virtualName", name);
 846         changed();
 847     }
 848 }
 849
 850 //==============================================================================
 851 void ComponentLayout::addToXml (XmlElement& xml) const
 852 {
 853     for (int i = 0; i < components.size(); ++i)
 854     {
 855         ComponentTypeHandler* h = ComponentTypeHandler::getHandlerFor (*components [i]);
 856
 857         if (h != 0)
 858             xml.addChildElement (h->createXmlFor (components [i], this));
 859     }
 860 }